use crate::ctp_commands::ctp::types::ApiResponse;
use std::fs;
use tauri::command;

/// 缓存管理模块
/// 专门用于清理 src-tauri 目录下的 CTP 缓存

/// 获取 CTP 缓存根目录路径（src-tauri/temp/ctp_cache）
pub fn get_ctp_cache_root_path() -> Result<std::path::PathBuf, String> {
    // 获取可执行文件所在目录（开发环境下是 src-tauri/target/debug，生产环境下是应用安装目录）
    let exe_dir = std::env::current_exe()
        .map_err(|e| format!("无法获取可执行文件路径: {}", e))?
        .parent()
        .ok_or("无法获取可执行文件父目录")?
        .to_path_buf();

    // 在开发环境下，需要向上找到 src-tauri 目录
    // 在生产环境下，直接使用可执行文件所在目录
    let src_tauri_dir = if exe_dir.ends_with("target/debug") || exe_dir.ends_with("target\\debug")
        || exe_dir.ends_with("target/release") || exe_dir.ends_with("target\\release") {
        // 开发环境：从 src-tauri/target/debug 向上两级到 src-tauri
        exe_dir.parent()
            .and_then(|p| p.parent())
            .ok_or("无法找到 src-tauri 目录")?
            .to_path_buf()
    } else {
        // 生产环境：使用可执行文件所在目录
        exe_dir
    };

    let ctp_cache_root = src_tauri_dir.join("temp").join("ctp_cache");

    println!("📁 [CACHE] CTP缓存根目录: {:?}", ctp_cache_root);

    Ok(ctp_cache_root)
}

/// 清理当前目录下的 CTP 缓存（删除所有缓存）
/// 直接删除 ctp_cache 目录下的所有内容（文件和文件夹）
pub fn cleanup_current_dir_cache() -> Result<String, String> {
    let cache_root = get_ctp_cache_root_path()?;

    if !cache_root.exists() {
        println!("ℹ️ [CACHE] CTP缓存目录不存在: {:?}", cache_root);
        return Ok("缓存目录不存在，无需清理".to_string());
    }

    println!("🔄 [CACHE] 开始清理CTP缓存: {:?}", cache_root);
    println!("📋 [CACHE] 策略: 删除所有缓存（文件和文件夹）");

    let mut cleaned_items = 0;
    let mut skipped_items = 0;

    // 读取缓存目录下的所有项目
    match fs::read_dir(&cache_root) {
        Ok(entries) => {
            for entry in entries {
                if let Ok(entry) = entry {
                    let path = entry.path();
                    let item_name = path
                        .file_name()
                        .and_then(|n| n.to_str())
                        .unwrap_or("未知")
                        .to_string();

                    // 判断是文件还是目录
                    if path.is_dir() {
                        println!("🗑️ [CACHE] 删除目录: {}", item_name);
                        match fs::remove_dir_all(&path) {
                            Ok(_) => {
                                cleaned_items += 1;
                                println!("  ✅ 已删除目录: {}", item_name);
                            }
                            Err(e) => {
                                skipped_items += 1;
                                println!("  ⚠️ 无法删除目录 {}: {}", item_name, e);
                            }
                        }
                    } else if path.is_file() {
                        println!("🗑️ [CACHE] 删除文件: {}", item_name);
                        match fs::remove_file(&path) {
                            Ok(_) => {
                                cleaned_items += 1;
                                println!("  ✅ 已删除文件: {}", item_name);
                            }
                            Err(e) => {
                                skipped_items += 1;
                                println!("  ⚠️ 无法删除文件 {}: {}", item_name, e);
                            }
                        }
                    }
                }
            }
        }
        Err(e) => {
            return Err(format!("读取缓存目录失败 {:?}: {}", cache_root, e));
        }
    }

    let result_msg = format!(
        "CTP缓存清理完成 - 已清理{}个项目，跳过{}个项目",
        cleaned_items, skipped_items
    );
    println!("✅ [CACHE] {}", result_msg);
    Ok(result_msg)
}

// Tauri 命令接口

/// 清理当前目录下的 CTP 缓存（删除所有缓存）
#[command]
pub fn cleanup_current_dir_cache_command() -> ApiResponse<String> {
    println!("🔄 [CACHE] 开始清理当前目录下的CTP缓存（删除所有缓存）");

    match cleanup_current_dir_cache() {
        Ok(result_msg) => ApiResponse {
            success: true,
            data: Some(result_msg),
            error: None,
        },
        Err(error) => ApiResponse {
            success: false,
            data: None,
            error: Some(error),
        },
    }
}
